package cn.itsource.service.impl;

import cn.itsource.annotation.CaoYuPiCacheAdd;
import cn.itsource.domain.CourseType;
import cn.itsource.mapper.CourseTypeMapper;
import cn.itsource.result.JSONResult;
import cn.itsource.service.ICourseTypeService;
import cn.itsource.vo.CrumbsVo;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author bobo
 * @since 2022-11-12
 */
@Service
@Slf4j
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {

    @Autowired
    private CourseTypeMapper courseTypeMapper;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 1、先查询缓存中是否有数据
     * 2、如果有数据，直接返回给前端即可
     * 3、如果没有数据，再去查数据库，将数据返回给前端，并且存一份到缓存中，以便下次可以查到
     */

    //获取课程分类树形数据接口
    @Override
    //@Cacheable(cacheNames = "course", key = "'treeData'")
    @CaoYuPiCacheAdd(cacheNames = "course", key = "treeData")
    public JSONResult treeData() {
        log.info("进入到方法中了");
        long t1 = System.currentTimeMillis();
        List<CourseType> returnList = new ArrayList<>();

        //查询所有课程类型数据(13条数据)
        List<CourseType> courseTypeList = courseTypeMapper.selectList(null);
        for(int i=0; i<courseTypeList.size(); i++){
            CourseType courseType = courseTypeList.get(i);//1037
            if(courseType.getPid() == 0){
                //说明该节点是根节点
                returnList.add(courseType);
            }else{
                //说明该节点是非根节点，可能是第1/2/3/4/5.....级节点，比然有父节点
                //1038节点
                for(int k=0; k<courseTypeList.size(); k++){
                    CourseType parentNode = courseTypeList.get(k);
                    if(courseType.getPid().longValue() == parentNode.getId().longValue()){
                        //说明找到父节点了
                        parentNode.getChildren().add(courseType);
                        break;
                    }
                }
            }
        }
        long t2 = System.currentTimeMillis();
        System.out.println("treeData方法执行耗时=" + (t2 - t1));
        return JSONResult.success(returnList);
    }

    //课程类型面包屑接口
    @Override
    public JSONResult crumbs(Long courseTypeId) {//1040

        /**
         * 1、根据入参用户选择的课程类型ID查询详情，可以得到一个 CourseType
         * 2、根据 CourseType 的pid(1039)查询，查询1039的所有子节点 List<CourseType>
         * 3、
         */
        List<CrumbsVo> list = new ArrayList<>();

        //根据入参查询对象信息
        CourseType courseType = courseTypeMapper.selectById(courseTypeId);

        String path = courseType.getPath();//1037.1039.1040
        String[] split = path.split("\\.");//1037 1039 1040

        CrumbsVo vo = null;
        for(int i=0; i<split.length; i++){
            String idString = split[i];//1037 1039 1040
            Long id = Long.valueOf(idString);

            //查询自己节点
            CourseType node = courseTypeMapper.selectById(id);
            //查询兄弟节点
            //select * from t_course_type where pid = 0 and id != 1037
            Wrapper wrapper = new EntityWrapper<CourseType>();
            wrapper.eq("pid", node.getPid()).and().ne("id", id);
            //入参节点的所有兄弟节点
            List<CourseType> broderList = courseTypeMapper.selectList(wrapper);

            vo = new CrumbsVo();
            vo.setOwnerCourseType(node);//自己本节点
            vo.setOtherCourseTypes(broderList);//所有兄弟节点
            list.add(vo);
        }
        return JSONResult.success(list);
    }

    //备份
    public JSONResult treeData3() {
        //1、查询缓存
        List<CourseType> redisData = (List<CourseType>)redisTemplate.opsForValue().get("treeData");

        if(redisData != null && redisData.size() > 0){
            log.info("从缓存中拿数据");
            //缓存中查询到了数据
            return JSONResult.success(redisData);
        }else{
            log.info("从数据库中拿数据");
            //缓存中没有查到数据，查DB
            long t1 = System.currentTimeMillis();
            List<CourseType> returnList = new ArrayList<>();
            //查询所有课程类型数据(13条数据)
            List<CourseType> courseTypeList = courseTypeMapper.selectList(null);
            for(int i=0; i<courseTypeList.size(); i++){
                CourseType courseType = courseTypeList.get(i);//1037
                if(courseType.getPid() == 0){
                    //说明该节点是根节点
                    returnList.add(courseType);
                }else{
                    //说明该节点是非根节点，可能是第1/2/3/4/5.....级节点，比然有父节点
                    //1038节点
                    for(int k=0; k<courseTypeList.size(); k++){
                        CourseType parentNode = courseTypeList.get(k);
                        if(courseType.getPid().longValue() == parentNode.getId().longValue()){
                            //说明找到父节点了
                            parentNode.getChildren().add(courseType);
                            break;
                        }
                    }
                }
            }
            long t2 = System.currentTimeMillis();
            System.out.println("treeData方法执行耗时=" + (t2 - t1));

            //存一份到缓存中
            redisTemplate.opsForValue().set("treeData", returnList);
            return JSONResult.success(returnList);
        }
    }

    //备份数据
    public JSONResult treeData2() {
        /**
         * 1、获取到所有的课程分类数据 List<CourseType> courseTypeList
         * 2、遍历courseTypeList，判断每一个节点的pid，是否是根节点
         * 3、如果是根节点，直接添加到返回结果集中即可
         * 4、如果不是根节点，那就循环所有节点，对比寻找自己的父节点，寻找到之后将自己放到父节点的Children集合中，循环终止
         */
        long t1 = System.currentTimeMillis();
        List<CourseType> returnList = new ArrayList<>();

        //查询所有课程类型数据(13条数据)
        List<CourseType> courseTypeList = courseTypeMapper.selectList(null);
        for(int i=0; i<courseTypeList.size(); i++){
            CourseType courseType = courseTypeList.get(i);//1037
            if(courseType.getPid() == 0){
                //说明该节点是根节点
                returnList.add(courseType);
            }else{
                //说明该节点是非根节点，可能是第1/2/3/4/5.....级节点，比然有父节点
                //1038节点
                for(int k=0; k<courseTypeList.size(); k++){
                    CourseType parentNode = courseTypeList.get(k);
                    if(courseType.getPid().longValue() == parentNode.getId().longValue()){
                        //说明找到父节点了
                        parentNode.getChildren().add(courseType);
                        break;
                    }
                }
            }
        }
        long t2 = System.currentTimeMillis();
        System.out.println("treeData方法执行耗时=" + (t2 - t1));
        return JSONResult.success(returnList);
    }
}